package com.visual.avplayer;

import android.app.job.JobInfo;
import android.app.job.JobScheduler;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Messenger;
import android.os.PersistableBundle;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.widget.Toast;
import android.widget.VideoView;

import com.orhanobut.logger.Logger;
import com.visual.avplayer.service.OnePixLiveService;

import java.lang.ref.WeakReference;

import androidx.appcompat.app.AppCompatActivity;
import cn.jzvd.JzvdStd;

public class MainActivity extends AppCompatActivity {
    private JzvdStd jzvdStd;
    private static final String TAG = "MainActivity";
    public static final String MESSENGER_INTENT_KEY = ".MESSENGER_INTENT_KEY";
    public static final String WORK_DURATION_KEY = ".WORK_DURATION_KEY";
    public static final int MSG_JOB_START = 0;
    public static final int MSG_JOB_STOP = 1;
    public static final int MSG_ONJOB_START = 2;
    public static final int MSG_ONJOB_STOP = 3;

    private int mJobId = 0;// 执行的JobId
    ComponentName mServiceComponent;// 这就是我们的jobservice组件了
    private IncomingMessageHandler mHandler;// 用于来自服务的传入消息的处理程序。

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mHandler = new IncomingMessageHandler(this);
        mServiceComponent = new ComponentName(this, MyJobService.class);// 获取到我们自己的jobservice，同时启动该service
//        startService(new Intent(this, SingASongService.class));

//        jzvdStd = findViewById(R.id.videoplayer);
//        jzvdStd.setUp("http://share.visualzhang.com/video/八段锦.mp4", "八段锦",
//                Jzvd.SCREEN_WINDOW_FULLSCREEN);
//        jzvdStd.thumbImageView.setImageResource(R.drawable.cover_baduanjing);
//        findViewById(R.id.btn_start_job).setOnClickListener(view -> this.scheduleJob());
//        OnePixLiveService.toLiveService(this);


        // Intent intent=new Intent(this,ForegroundLiveService.class);
        //startService(intent);

        // Intent intent=new Intent(this,NotificationLiveService.class);
        //startService(intent);

        // Intent intent=new Intent(this,MyJobService.class);
        //startService(intent);
    }

    @Override
    protected void onResume() {
        super.onResume();
        VideoViewActivity.launch(this);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // 启动服务并提供一种与此类通信的方法。
        Intent startServiceIntent = new Intent(this, MyJobService.class);
        Messenger messengerIncoming = new Messenger(mHandler);
        startServiceIntent.putExtra(MESSENGER_INTENT_KEY, messengerIncoming);
        startService(startServiceIntent);
    }

    @Override
    protected void onStop() {
        // 服务可以是“开始”和/或“绑定”。 在这种情况下，它由此Activity“启动”
        // 和“绑定”到JobScheduler（也被JobScheduler称为“Scheduled”）。
        // 对stopService（）的调用不会阻止处理预定作业。
        // 然而，调用stopService（）失败将使它一直存活。
        stopService(new Intent(this, MyJobService.class));
        super.onStop();
    }

    // 当用户单击SCHEDULE JOB时执行。
    public void scheduleJob() {
        //开始配置JobInfo
        JobInfo.Builder builder = new JobInfo.Builder(mJobId++, mServiceComponent);

        //设置任务的延迟执行时间(单位是毫秒)
        String delay = "3";
        if (!TextUtils.isEmpty(delay)) {
            builder.setMinimumLatency(Long.valueOf(delay) * 1000);
        }
        //设置任务最晚的延迟时间。如果到了规定的时间时其他条件还未满足，你的任务也会被启动。
        String deadline = "5";
        if (!TextUtils.isEmpty(deadline)) {
            builder.setOverrideDeadline(Long.valueOf(deadline) * 1000);
        }
        boolean requiresUnmetered = false;
        boolean requiresAnyConnectivity = true;

        //让你这个任务只有在满足指定的网络条件时才会被执行
        if (requiresUnmetered) {
            builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_UNMETERED);
        } else if (requiresAnyConnectivity) {
            builder.setRequiredNetworkType(JobInfo.NETWORK_TYPE_ANY);
        }

        //你的任务只有当用户没有在使用该设备且有一段时间没有使用时才会启动该任务。
        builder.setRequiresDeviceIdle(false);
        //告诉你的应用，只有当设备在充电时这个任务才会被执行。
        builder.setRequiresCharging(false);

        // Extras, work duration.
        PersistableBundle extras = new PersistableBundle();
        String workDuration = "10";
        if (TextUtils.isEmpty(workDuration)) {
            workDuration = "1";
        }
        extras.putLong(WORK_DURATION_KEY, Long.valueOf(workDuration) * 1000);

        builder.setExtras(extras);

        // Schedule job
        Logger.e("Scheduling job");
        JobScheduler mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        // 这里就将开始在service里边处理我们配置好的job
        mJobScheduler.schedule(builder.build());

        //mJobScheduler.schedule(builder.build())会返回一个int类型的数据
        //如果schedule方法失败了，它会返回一个小于0的错误码。否则它会返回我们在JobInfo.Builder中定义的标识id。
    }

    // 当用户点击取消所有时执行
    public void cancelAllJobs() {
        JobScheduler mJobScheduler = (JobScheduler) getSystemService(Context.JOB_SCHEDULER_SERVICE);
        mJobScheduler.cancelAll();
        Toast.makeText(MainActivity.this, "取消所有jobs", Toast.LENGTH_SHORT).show();
    }

    /**
     * {@link Handler}允许您发送与线程相关联的消息。
     * {@link Messenger}使用此处理程序从{@link MyJobService}进行通信。
     * 它也用于使开始和停止视图在短时间内闪烁。
     */
    private static class IncomingMessageHandler extends Handler {

        // 使用弱引用防止内存泄露
        private WeakReference<MainActivity> mActivity;

        IncomingMessageHandler(MainActivity activity) {
            super(/* default looper */);
            this.mActivity = new WeakReference<>(activity);
        }

        @Override
        public void handleMessage(Message msg) {
            MainActivity mSchedulerAcitvity = mActivity.get();
            if (mSchedulerAcitvity == null) {
                // 活动不再可用，退出。
                return;
            }

            // 获取到两个View，用于之后根据Job运行状态显示不同的运行状态（颜色变化）

            Message m;
            switch (msg.what) {
                // 当作业登录到应用程序时，从服务接收回调。 打开指示灯（上方View闪烁）并发送一条消息，在一秒钟后将其关闭。
                case MSG_JOB_START:
                    // Start received, turn on the indicator and show text.
                    // 开始接收，打开指示灯（上方View闪烁）并显示文字。

                    // Send message to turn it off after a second.
                    // 发送消息，一秒钟后关闭它。
                    m = Message.obtain(this, MSG_ONJOB_START);
                    sendMessageDelayed(m, 1000L);
                    Logger.e("MSG_JOB_START");
                    break;

                // 当先前执行在应用程序中的作业必须停止执行时，
                // 从服务接收回调。 打开指示灯并发送一条消息，
                // 在两秒钟后将其关闭。
                case MSG_JOB_STOP:
                    // Stop received, turn on the indicator and show text.
                    // 停止接收，打开指示灯并显示文本。

                    // Send message to turn it off after a second.
                    // 发送消息，一秒钟后关闭它。
                    m = obtainMessage(MSG_ONJOB_STOP);
                    sendMessageDelayed(m, 2000L);
                    Logger.e("MSG_JOB_STOP");
                    break;
                case MSG_ONJOB_START:
                    Logger.e("MSG_ONJOB_START");
                    break;
                case MSG_ONJOB_STOP:
                    Logger.e("MSG_ONJOB_STOP");
                    break;
            }
        }
    }
}